\chapter{Compilazione a oggetti di un linguaggio funzionale}

In questo capitolo vengono mostrati due linguaggi da noi definiti,
chiamati {\flang} e {\olang}.
Il primo \`e un linguaggio funzionale mentre il secondo \`e un linguaggio
a oggetti puro.
Dopo avere descritto la sintassi e la semantica di entrambi i linguaggi
mostreremo che la compilazione di {\flang} in {\olang} avviene in 
maniera molto naturale. 

\section{\label{sec:flang}Il linguaggio \flang}

Il linguaggio {\flang} \`e un linguaggio funzionale minimale, che per\`o 
conserva tutte le caratteristiche di un linguaggio funzionale.
Infatti le funzioni sono trattate come elementi
di \emph{prima classe}, \`e possibile  
specializzare una funzione tramite \emph{l'applicazione parziale}, 
definire funzioni \emph{mutuamente ricorsive}\footnote{La mutua ricorsione
\`e una forma di ricorsione in cui due funzioni sono definite una in termini
dell'altra} ed \`e fondamentale l'uso della \emph{ricorsione}. 
Si \`e deciso di non fornire il linguaggio
di costrutti come la \textit{selezione} o il \textit{binding}, per concentrare
l'attenzione solo sulle caratteristiche funzionali.
In {\flang}, un programma consiste in una sola espressione in
quanto non esistono direttive globali. Vediamo alcuni esempi:
%
\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}
\begin{ScriptMath}
  fun f g x $\to$ f (g x)
\end{ScriptMath} 
%
Questa funzione \`e la versione anonima della funzione \lstinline!compose! vista nel capitolo precedente.
In questo esempio si vede innanzitutto che il linguaggio tratta le funzioni come
elementi di prima classe. Infatti la funzione accetta come argomenti 
\lstinline!f! e \lstinline!g!
che sono delle funzioni.
Inoltre si vede anche l'uso dell'applicazione parziale, in quanto prima si 
applica la funzione \lstinline!g! a \lstinline!x! 
e poi si applica il risultato a \lstinline!f!. La seguente funzione:
%
\begin{ScriptMath}
  fix f = fun x $\to$ f x
\end{ScriptMath} 
%
mostra in che modo \`e possibile implementare un loop
infinito in {\flang} facendo uso della ricorsione.
Infatti la funzione \lstinline!f! applica ricorsivamente se stessa 
al parametro \lstinline!x!.
Non essendoci l'iterazione nei linguaggi funzionali, la ricorsione assume un 
ruolo fondamentale. Infine questo esempio:
%
\begin{ScriptMath}
  fix f = fun x $\to$ g x
  and g = fun y $\to$ f y
\end{ScriptMath}
%
mostra l'uso della mutua ricorsione, utile come
in questo caso quando due funzioni fanno chiamate ricorsive reciproche.

In questa sezione abbiamo deciso di mostrare degli esempi molto semplici
del linguaggio {\flang} che servono solo a mostrare le caratteristiche
funzionali dello stesso, anche se il linguaggio permetterebbe di definire
funzioni ben pi\`u complesse. 
Esempi pi\`u significativi verranno mostrati nel capitolo successivo
usando un'estensione del linguaggio {\flang} che offre una sintassi 
pi\`u ricca per il programmatore. 


\subsection {Sintassi del linguaggio~\flang}

La sintassi del linguaggio funzionale {\flang} \`e mostrata in
Tabella~\ref{tab:fsyntax} e utilizza un insieme di \emph{variabili}
denotate da $x$, $y$, \dots. La sintassi consta di due categorie
sintattiche, $\VAL$ per i \emph{valori} e $\EXPR$ per le
\emph{espressioni}. Usiamo la notazione $\sequence{X}$ per denotare
una sequenza non vuota $X_1,\dots,X_n$ di valori/espressioni.
%
Una espressione atomica pu\`o essere un valore $v$ o una variabile
$x$.
%
L'espressione $\EXPR~\EXPR_1\cdots\EXPR_n$ denota l'applicazione della
funzione $\EXPR$ agli argomenti $\EXPR_1\cdots\EXPR_n$.
%
L'espressione $\kfix{k}$ denota la definizione di $n$ funzioni
mutuamente ricorsive, ciascuna con nome $\VAR_i$. L'intera espressione
\`e equivalente alla $k$-esima funzione definita, ovvero a $\VAL_k$.

Per quanto riguarda i valori, il termine
$\mathtt{fun}~\VAR_1\cdots\VAR_n \to \EXPR$ denota una funzione a $n$
argomenti $x_1,\dots,x_n$ il cui corpo \`e l'espressione $\EXPR$.
%
Il termine
$\mathtt{pap}~(\mathtt{fun}~\VAR_1\cdots\VAR_n\to\EXPR)~\VAL_1\cdots\VAL_m$
denota l'applicazione parziale della funzione
$\mathtt{fun}~\VAR_1\cdots\VAR_n\to\EXPR$ agli argomenti
$\VAL_1,\dots,\VAL_m$. In quanto parziale, deve essere $n > m$, ovvero
la funzione accetta pi\`u argomenti di quelli effettivamente
forniti. Il fatto che i termini rappresentanti applicazioni parziali
sono evidenziati con $\rtsyntax{\text{sfondo grigio}}$ sta a indicare
che tali termini possono comparire solo durante la valutazione di una
espressione del linguaggio {\flang}. Pertanto, tali termini \emph{non}
compaiono nei programmi scritti dal programmatore.

\begin{table}%[!h]
\caption{\label{tab:fsyntax} Sintassi del linguaggio~\flang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{rcl@{\qquad}l}
\VAL & ::= & \mathtt{fun}~\sequence{\VAR}\to\EXPR \\
  & | & \rtsyntax{\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL}} & \seqlen{\sequence{\VAR}} > \seqlen{\sequence{\VAL}} \\
\\
\EXPR & ::= & \VAL \\
  & | & \VAR \\
  & | & \EXPR~\sequence{\EXPR} & \\
  & | & \varkfix{k} & 1 \le k \le \seqlen{\sequence{\VAR}} \\
\end{array}
\end{math}
}
\end{table}


\subsection {Semantica del linguaggio \flang}

La semantica del linguaggio {\flang} \`e mostrata in
Tabella~\ref{tab:feval}. Nei paragrafi seguenti verranno
spiegate singolarmente le regole contenute in essa.

La lunghezza di una sequenza $\sequence\VAR$ \`e scritta 
$\seqlen{\sequence{\VAR}}$.
La notazione ${\EXPR\subst{\sequence{\VAL}}{\sequence{\VAR}}}$
\`e una abbreviazione per 
${\EXPR\subst{\VAL_1}{\VAR_1}\cdots\subst{\VAL_n}{\VAR_n}}$;
sta ad indicare che nell'espressione $\EXPR$ ogni occorrenza di 
$\VAR_1$ va \emph{sostituita} sintatticamente con $\VAL_1$ e cos\`i via 
fino a sostituire $\VAR_n$ con $\VAL_n$.
La virgola \`e usata per denotare la concatenazione di sequenze.
Per dire che l'espressione $a$ si riduce a $b$ scriviamo
 ``$a~\to~b$''.
   
Con $\EVAL{\EXPR}$ denotiamo una generica espressione in cui occorre
$\EXPR$. Siccome il calcolo \`e confluente non dobbiamo preoccuparci
dell'ordine di valutazione.

\begin{table}%[!h]
\caption{\label{tab:feval} Valutazione delle espressioni del linguaggio \flang.}
\framebox[\textwidth]{
\begin{small}
\begin{math}
\displaystyle
\begin{array}{@{}c@{}}
\inferrule[\rulename{E-Sat}]{
  \seqlen{\sequence{\VAR}} = \seqlen{\sequence{\VAL}}
}{
  {(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL}}
  \to
  {\EXPR\subst{\sequence{\VAL}}{\sequence{\VAR}}}
}
\qquad
\inferrule[\rulename{E-SatApp}]{
  \seqlen{\sequence{\VAR}} = \seqlen{\sequence{\VAL}}
}{
  {(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL},\sequence{\VARVAL}}
  \to
  {\EXPR\subst{\sequence{\VAL}}{\sequence{\VAR}}~\sequence{\VARVAL}}
}
\\\\
\inferrule[\rulename{E-Pap}]{
  \seqlen{\sequence{\VAR}} > \seqlen{\sequence{\VAL}}
}{
  {(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL}}
  \to
  {\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL}}
}
\qquad
\inferrule[\rulename{E-PapSat}]{
  \seqlen{\sequence{\VAR}} = \seqlen{\sequence{\VAL},\sequence{\VARVAL}}
}{
  {(\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL})~\sequence{\VARVAL}}
  \to
  {\EXPR\subst{\sequence{\VAL},\sequence{\VARVAL}}{\sequence{\VAR}}}
}
\\\\
\quad
\inferrule[\rulename{E-PapSatApp}]{
  \seqlen{\sequence{\VAR}} = \seqlen{\sequence{\VAL},\sequence{\VARVAL}}
}{
  {(\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL})~\sequence{\VARVAL},\sequence{\VARVAL}'}
  \to
  {\EXPR\subst{\sequence{\VAL},\sequence{\VARVAL}}{\sequence{\VAR}}~\sequence{\VARVAL}'}
}
\\\\
\qquad
\inferrule[\rulename{E-PapPap}]{
  \seqlen{\sequence{\VAR}} > \seqlen{\sequence{\VAL},\sequence{\VARVAL}}
}{
  {(\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL})~\sequence{\VARVAL}}
  \to
  {\mathtt{pap}~(\mathtt{fun}~\sequence{\VAR}\to\EXPR)~\sequence{\VAL},\sequence{\VARVAL}}
}
\\\\
\inferrule[\rulename{E-Fix}]{}{
  {\varkfix{k}}
  \to
  {\VAL_k\subst{\varkfix{1}}{x_1}}\cdots\subst{\varkfix{n}}{x_n}
}
% \\\\
% \inferrule{
%   \VARVAL_i = \VAL_i\subst{\mathtt{let}~\mathtt{rec}~\VAR_1=\VAL_1\cdots\VAR_n=\VAL_n~\mathtt{in}~\VAR_j}{\VAR_j}^{j=1..n}
% }{
%   {\mathtt{let}~\mathtt{rec}~\VAR_1=\VAL_1\cdots\VAR_n=\VAL_n~\mathtt{in}~\EXPR}
%   \to
%   {\EXPR\subst{\VARVAL_i}{\VAR_i}^{i=1..n}}
% }
\qquad
\inferrule[\rulename{E-Context}]{
  \EXPR \to \EXPR'
}{
  \EVAL{\EXPR} \to \EVAL{\EXPR'}
}
\end{array}
\end{math}
\end{small}
}
\end{table}

\paragraph{ E-Sat }

Questa regola di inferenza spiega come viene trattata la saturazione di un'applicazione.
La premessa della regola \`e che il numero di parametri attuali passati ad una funzione
coincida con il numero di parametri formali della funzione.
La conclusione dice che la valutazione dell'applicazione della funzione si 
riduce al corpo della funzione stessa, sostituendo i parametri formali con quelli
attuali.

\paragraph{ E-SatApp }

Questa regola di inferenza spiega come viene trattata l'applicazione di una funzione 
ad un numero di parametri maggiore rispetto a quelli necessari per saturarla.
La conclusione dice che prima viene saturata l'applicazione con il numero di parametri attesi, 
successivamente il risultato di questa riduzione viene applicato ai parametri restanti.

\paragraph{ E-Pap }

Questa regola di inferenza spiega come viene trattata l'applicazione di una funzione 
ad un numero di parametri minore rispetto a quelli necessari per saturarla.
La conclusione dice che la valutazione dell'applicazione della funzione si 
riduce alla creazione di un'\emph{applicazione parziale o specializzazione}
della funzione stessa con i parametri passati.

\paragraph{ E-PapSat }

Questa regola di inferenza spiega come viene trattata l'applicazione di una  
funzione specializzata ad un numero di parametri tale da saturare l'applicazione.
La conclusione dice che la valutazione dell'applicazione della funzione specializzata si 
riduce al corpo della funzione stessa, sostituendo i parametri formali con quelli
attuali.

\paragraph{ E-PapSatApp}

Questa regola di inferenza spiega come viene trattata l'applicazione di una  
funzione specializzata ad un numero di parametri maggiore rispetto a quelli necessari per saturarla.
La conclusione dice che prima viene saturata l'applicazione con il numero di parametri attesi,
ed il risultato di questa riduzione viene applicato ai parametri restanti.

\paragraph{ E-PapPap}

Questa regola di inferenza spiega come viene trattata l'applicazione di una  
funzione specializzata a un numero di parametri minore rispetto a quelli necessari per saturarla.
La conclusione dice che la valutazione dell'applicazione della funzione specializzata, si 
riduce alla creazione di una nuova \emph{applicazione parziale o specializzazione}
della funzione stessa con i parametri passati.

\paragraph{ E-Fix}

Questo assioma spiega come viene trattata la definizione di un certo numero di funzioni mutuamente ricorsive.
La valutazione dell'intera espressione si riduce al valore del $k$-esimo elemento definito,
avendo sostituito a ogni definizione il relativo nome.

\paragraph{ E-Contex}

Questa regola di inferenza spiega l'indipendenza dal contesto.  
Se una espressione $E$ si riduce a $E'$, allora una generica espressione in cui occorre $E$ si 
riduce alla stessa espressione, avendo ridotto $E$ in $E'$.\\

Vediamo ora alcuni esempi di applicazione delle regole appena descritte:

\begin{ScriptMath}
(fun f g x $ \to $ f (g x)) not even 3
not (even 3)
\end{ScriptMath}
%
In questo esempio \`e stata applicata la regola \textit{E-Sat} visto che il numero di argomenti
passati alla funzione corrisponde al numero dei parametri formali; l'intera espressione
viene quindi ridotta al corpo della funzione, avendo sostituito i parametri formali con quelli attuali.

Ora modifichiamo leggermente la definizione della funzione, spezzando la funzione a tre argomenti in
una funzione a due argomenti il cui corpo \`e una funzione ad un argomento:
%
\begin{ScriptMath}
(fun f g $\to$ fun x $ \to $ f (g x)) not even 3 
(fun x $\to$ not (even x)) 3 
not (even 3)
\end{ScriptMath}
%
In questo caso il numero di parametri passati alla funzione \`e maggiore del 
numero di parametri necessari a saturarla. Per questo viene prima applicata 
la regola di riduzione \textit{E-SatApp}, ottenendo una funzione
ad un argomento a cui deve essere applicato proprio un argomento; applicando
poi la regola \textit{E-Sat} l'espressione si riduce al corpo
della funzione in cui i parametri formali sono sostituiti da quelli attuali.

Rimodifichiamo la funzione facendo in modo di passargli un parametro alla volta:
%
\begin{ScriptMath}
(((fun f g x $ \to $ f (g x)) not) even) 3
(((pap (fun f g x $ \to $ f (g x)) not) even) 3)
((pap (fun f g x $ \to $ f (g x)) not even) 3)
not (even 3)
\end{ScriptMath}
%
Per valutare la prima espressione occorre usare due regole di riduzione visto 
che c'\`e l'applicazione di una funzione all'interno di un contesto.
Grazie alla regola \textit{E-Contex} per\`o possiamo tranquillamente valutare
l'applicazione della funzione indipendentemente dal contesto.
In questo caso il numero di argomenti passati alla funzione \`e minore del 
numero di argomenti necessari a saturarla e per questo viene applicata la
regola \textit{E-Pap} che crea un'applicazione parziale della funzione col
primo argomento.
Passando un ulteriore argomento alla \textit{pap} appena creata, otteniamo una
nuova \textit{pap} visto che \`e necessario un ulteriore argomento per 
saturarla. Questa sostituzione \`e possibile grazie alla regola \textit
{E-PapPap}.
A questo punto passando alla \textit{pap} l'ultimo argomento l'intera 
espressione si riduce al corpo della funzione, sostituendo i parametri formali
con quelli attuali. Questa sostituzione \`e possibile grazie alla regola \textit{E-PapSat}.

\section {Analogie fra la compilazione di \flang~ed i linguaggi a oggetti }
Come abbiamo visto nel capitolo predente, la compilazione dei linguaggi 
funzionali avviene tramite le \emph{chiusure} e
le chiusure sono generalmente implementate tramite una struttura dati che
contiene sia il codice della funzione sia la rappresentazione dell'ambiente
nel momento in cui la chiusura \`e stata creata.
Una struttura dati atta a contenere sia dati che funzioni \`e proprio un
oggetto.
Infatti un oggetto \`e l'istanza di una classe e una classe \`e formata
da un insieme di attributi e un insieme di metodi.

L'idea \`e quindi quella di implementare le chiusure tramite gli oggetti,
usando i campi della classe per memorizzare le variabili libere e 
usando un metodo per implementare la funzione stessa. Vediamo un esempio:\\

\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}
\makebox[\textwidth]{
\begin{tabular}{lc@{\qquad}l}
 & &\lstinline! class C \{! \\
\lstinline!let a = 1! & &  \lstinline!a;! \\
\lstinline!let f x = x + a! &\quad $\xrightarrow[\qquad]{}$ &
\lstinline!C (a)\{ this.a = a;\}! \\
& & \lstinline!apply(x)\{!\\
& & \quad \lstinline!return(x + this.a);! \\
& & \quad \lstinline!\}! \\
& & \lstinline!\}! \\
& & \\
\end{tabular}
}
%
In questo esempio al momento della definizione di \lstinline!f! 
l'unica variabile libera 
\`e \lstinline!a! quindi la classe creata ha un unico attributo, che verr\`a 
opportunamente inizializzato dal costruttore della classe.
La classe inoltre ha un metodo che rappresenta il corpo della funzione, e
realizza la saturazione della funzione.
In questo esempio non \`e evidente come sia possibile l'applicazione parziale
di una funzione. Essa avviene tramite la definizione di una classe di 
supporto, che verr\`a estesa da ogni chiusura, in cui sono presenti i metodi
per applicare una funzione ad un numero arbitrario di argomenti.
Il sistema poi usando il \emph{late binding} chiamer\`a la funzione opportuna
in base al tipo runtime dell'oggetto sul quale \`e invocata.
Questo meccanismo verr\`a approfondito nella Sezione~\ref{sec:comp}.
Un oggetto inoltre pu\`o essere passato come argomento di una funzione,
pu\`o essere il risultato di una funzione ed \`e possibile memorizzare un
oggetto come attributo di una classe; proprio le caratteristiche che deve
avere una chiusura. 
Questo ci convince ulteriormente della bont\`a della scelta di mappare le
chiusure in oggetti.

\section{Il linguaggio \olang}
Il linguaggio {\olang} \`e un linguaggio a oggetti molto semplice,
simile a \emph{Featherweight Java}~\cite{fwj}.\footnote{Featherweight Java
\`e un linguaggio tipato a differenza di {\olang} e ammette anche il 
\textit{cast},
mentre {\olang} ammette la definizione di oggetti mutuamente ricorsivi.}
Il linguaggio non \`e tipato e un programma consiste in un insieme di 
definizioni
di classi pi\`u un'espressione da valutare.\footnote{Questa espressione 
corrisponde al corpo del metodo \textit{main} in Java}
Questo linguaggio \`e  a oggetti puro, nel senso che non \`e presente 
un comando di  assegnamento. Grazie a questo, non dobbiamo preoccuparci 
dei \emph{side effect}. 

\subsection {Sintassi del linguaggio~\olang }
La sintassi del linguaggio a oggetti {\olang} \`e mostrata in
Tabella~\ref{tab:osyntax} e consta di 5 categorie sintattiche:

\begin{itemize}
\item $\CLASS$ per la dichiarazione delle classi
\item $\CTOR$ per il costruttore di una classe
\item $\METHOD$ per la dichiarazione dei metodi di una classe
\item $\EXPR$ per le \emph{espressioni}
\item $\REF$ per i riferimenti
\end{itemize}
 
Usiamo la notazione $\sequence{\FIELDID}$ per denotare
una sequenza eventualmente vuota $f_0,\dots,f_n$ di attributi di una classe.
La stessa notazione ha lo stesso significato anche per quanto riguarda 
i metodi, i parametri formali di un metodo, i parametri attuali di un metodo
e l'inizializzazione di riferimenti che rappresentano istanze di una classe.
%
Una classe ha un nome, estende una classe base e ha un insieme di attributi, un costruttore e un insieme di metodi.
%
Il costruttore di una classe ha tanti parametri quanti sono gli attributi della classe e si limita ad inizializzare gli attributi con i valori che gli sono passati.
%
Un metodo ha un nome, una lista di parametri e il suo corpo \`e un'espressione del linguaggio \olang.
%
L'espressione $\knew{k}$ denota la creazione di $n$ oggetti
mutuamente ricorsivi, ciascuno con nome $\REF_i$. L'intera espressione
\`e equivalente al $k$-esimo oggetto definito, ovvero a $\REF_k$.
%
L'espressione $\EXPR.\FIELDID$ denota l'accesso al campo $\FIELDID$ dell'oggetto derivante 
dalla valutazione di $\EXPR$.
%
L'espressione $\EXPR.\METHODID(\EXPR_1\cdots\EXPR_n)$ denota la chiamata del metodo $\METHODID$ 
dell'oggetto derivante alla valutazione di $\EXPR$. Naturalmente $n$ deve essere il numero di 
parametri formali del metodo $\METHODID$.  
%
Inoltre una espressione pu\`o essere un riferimento ad un oggetto precedentemente allocato.
il valore $\nil$ sta ad indicare un riferimento ad un oggetto non ancora allocato, 
mentre il valore $\OBJECTID$ sta ad indicare il puntatore dell'oggetto nello 
\textit{heap}.

\begin{table}%[!h]
\caption{\label{tab:osyntax} Sintassi del linguaggio \olang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{rcl@{\qquad}l}
\CLASS & ::= & \mathtt{class}~\CLASSID~\mathtt{extends}~\CLASSID~\{
  \sequence{\FIELDID};
  ~\CTOR
  ~\sequence{\METHOD}
  \} \\
\\
\CTOR & ::= & \CLASSID(\sequence{\FIELDID})
  ~\{\THIS.\sequence{\FIELDID}=\sequence{\FIELDID};\} \\
\\
\METHOD & ::= & \METHODID(\sequence{\VAR})~\{\EXPR\} \\
\\
\EXPR & ::= & \REF \\
& | & \EXPR.\FIELDID \\
& | & \EXPR.\METHODID(\sequence{\EXPR}) \\
& | & \mathtt{new}_k~\sequence{\REF} = \sequence{\CLASSID(\sequence{\EXPR})} & 1 \le k \le \seqlen{\sequence{\REF}} \\
\\
\REF & ::= & \VAR \mid \rtsyntax{\OBJECTID \mid \nil} \\
\end{array}
\end{math}
}
\end{table}

\subsection {Semantica del linguaggio~\olang}

La semantica del linguaggio {\olang} \`e mostrata nelle
Tabelle~\ref{tab:fields}, \ref{tab:methods} e \ref{tab:obj-eval}.
La notazione usata in queste tabelle \`e simile alla notazione usata 
per descrivere
la semantica del linguaggio {\flang}.
Nei paragrafi seguenti verranno
spiegate singolarmente le regole contenute in esse.
Inoltre in queste tabelle vengono usate le seguenti funzioni ausiliare:
$\fields({\CLASSID})$ , $\body(\METHODID,\CLASSID)$ e $\HEAP(\OBJECTID)$. 


I campi di una classe $\CLASSID$, scritti $\fields({\CLASSID})$,
sono una sequenza di nomi di campi dichiarati nella classe $\CLASSID$ 
ed in ogni classe della gerarchia da cui deriva $\CLASSID$.
Rappresentiamo l'insieme vuoto con $\bullet$.
%
Il corpo del metodo $\METHODID$ della classe $\CLASSID$,
scritto $\body(\METHODID, \CLASSID)$, 
\`e una coppia $(\sequence{x},\EXPR)$, con $\sequence{x}$ che rappresenta la
lista dei parametri del metodo ed $\EXPR$ che rappresenta il corpo del
metodo.
%
Lo stato dell'oggetto $\OBJECTID$, scritta $\HEAP(\OBJECTID)$, \`e la classe 
$\CLASSID(\sequence{\VAROBJECTID})$ dell'oggetto
che \`e memorizzato nello \emph{heap}, con la sequenza
di valori dei suo campi $\sequence{\VAROBJECTID}$.   
Lo \emph{heap} \`e l'area di memoria in cui vengono memorizzate gli oggetti
a runtime.
Con $\EVAL{\EXPR},\HEAP$ denotiamo una generica espressione in cui occorre
$\EXPR$, essendo $\HEAP$ lo \emph{heap}.
Infine la notazione 
$\HEAP[\OBJECTID \mapsto \CLASSID(\sequence{\VAROBJECTID})]$,
sta ad indicare l'allocazione nello heap dell'oggetto $\OBJECTID$ di classe
$\CLASSID$, passandogli come parametri la lista di valori 
$\sequence{\VAROBJECTID}$ . 



\begin{table}%[!h]
\caption{\label{tab:fields}\strut Campi di una classe.}
\framebox[\textwidth]{
\begin{small}
\begin{math}
\displaystyle
\begin{array}{@{}c@{}}
  \inferrule{}{
    \fields(\mathtt{Object}) = {\bullet}
  }
  \quad
  \inferrule{
    \CT(\CLASSID) = \mathtt{class}~\CLASSID~\mathtt{extends}~\VARCLASSID~\{
    \sequence{\FIELDID};
    ~
    \CTOR
    ~
    \sequence{\METHOD}
    \}
    \quad
    \fields(\VARCLASSID) = \sequence{\VARFIELDID}
  }{
    \fields(\CLASSID) = \sequence{\VARFIELDID},\sequence{\FIELDID}
  }
\end{array}
\end{math}
\end{small}
}
\end{table}

\paragraph{Campi di una classe}
Nella Tabella~\ref{tab:fields} viene illustrato il modo con cui sono calcolati
i campi di una classe.
Questa tabella ha un assioma che dice che la classe \textit{Object}
non ha campi.\footnote{In Java la classe \textit{Object} \`e la classe da cui
derivano tutte le altre classi}
La regola di inferenza, invece, stabilisce quali sono i campi di una classe.
La regola ha due premesse: i campi dichiarati nella definizione di
$\CLASSID$ sono $\sequence{f}$. I campi della gerarchia della classe che 
viene estesa da $\CLASSID$ sono $\sequence{g}$.
La conclusione dice che i campi di $\CLASSID$ sono sia i campi dichiarati
nella definizione di $\CLASSID$, sia i campi della gerarchia della classe
che viene estesa da $\CLASSID$.

\begin{table}%[!h]
\caption{\label{tab:methods}\strut Risoluzione di metodo.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{@{}c@{}}
  \inferrule{
    \CT(\CLASSID) = \mathtt{class}~\CLASSID~\mathtt{extends}~\VARCLASSID~\{
    \sequence{\FIELDID};
    ~
    \CTOR
    ~
    \sequence{\METHOD}
    \}
    \\
    \METHODID(\sequence{x})~\{\EXPR\} \in \sequence{\METHOD}
  }{
    \body(\METHODID, \CLASSID) = (\sequence{x}, \EXPR)
  }
  \\\\
  \inferrule{
    \CT(\CLASSID) = \mathtt{class}~\CLASSID~\mathtt{extends}~\VARCLASSID~\{
    \sequence{\FIELDID};
    ~
    \CTOR
    ~
    \sequence{\METHOD}
    \}
    \\
    \text{$\METHODID$ non definito in $\sequence{\METHOD}$}
  }{
    \body(\METHODID, \CLASSID) = \body(\METHODID, \VARCLASSID)
  }
\end{array}
\end{math}
}
\end{table}


\paragraph{Risoluzione di metodo}
Nella Tabella~\ref{tab:methods} viene illustrato in che modo avviene la 
risoluzione dei metodi. Questa tabella ha due regole di inferenza.
La prima regola dice che se definisco una classe $\CLASSID$, che contiene un metodo $\METHODID$,
il cui corpo \`e $\EXPR$, e ha una lista di parametri $\sequence{x}$, allora il risultato della
funzione \textit{body} applicata al metodo $\METHODID$ e alla classe $\CLASSID$ \`e proprio la coppia
$\{\sequence{x},\EXPR\}$.

La seconda regola dice invece che se la classe $\CLASSID$ non contiene il metodo $\METHODID$, la 
funzione \textit{body} applicata al metodo $\METHODID$ e alla classe $\CLASSID$, equivale alla stessa
chiamata di funzione con parametri $\METHODID$ e $\VARCLASSID$, cio\`e il metodo $\METHODID$
sar\`a definito in una classe della gerarchia di $\VARCLASSID$.\\

\begin{table}%[!h]
\caption{\label{tab:obj-eval}\strut Valutazione delle espressioni del linguaggio \olang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{@{}c@{}}
  \inferrule[\rulename{E-Field}]{
    \HEAP(\OBJECTID) = \CLASSID(\sequence{\VAROBJECTID})
    \\
    \fields(\CLASSID) = \sequence{\FIELDID}
  }{
    \EVAL{\OBJECTID.\FIELDID_i}, \HEAP
    \to
    \EVAL{\VAROBJECTID_i}, \HEAP
  }
  \qquad
  \inferrule[\rulename{E-Method}]{
    \HEAP(\OBJECTID) = \CLASSID(\sequence{\VAROBJECTID})
    \\
    \body(\METHODID, \CLASSID) = (\sequence{\VAR},\EXPR)
  }{
    \EVAL{\OBJECTID.\METHODID(\sequence{\OBJECTID})},
    \HEAP
    \to
    \EVAL{\EXPR\subst{\sequence{\OBJECTID}}{\sequence{\VAR}}\subst{\OBJECTID}{\THIS}},
    \HEAP
  }
  % \qquad
  % \inferrule[\rulename{E-Let}]{}{
  %   \EVAL{\mathtt{let}~\sequence{\VAR}=\sequence{\OBJECTID}~\mathtt{in}~\EXPR},
  %   \HEAP
  %   \to
  %   \EVAL{\EXPR\subst{\sequence{\OBJECTID}}{\sequence{\VAR}}},
  %   \HEAP
  % }
  \\\\
  \inferrule[\rulename{E-Alloc}]{
    \OBJECTID_i \not\in \dom(\HEAP)
  }{
    \EVAL{\mathtt{new}_k~\sequence{\VAR} = \sequence{\CLASSID(\sequence{\EXPR})}},
    \HEAP
    \to
    \EVAL{\mathtt{new}_k~\sequence{\OBJECTID} = \sequence{\CLASSID(\sequence{\EXPR}\subst{\sequence{\OBJECTID}}{\sequence{\VAR}})}},
    \HEAP[\sequence{\OBJECTID} \mapsto \sequence{\CLASSID(\sequence{\nil})}]
  }
  \\\\
  \inferrule[\rulename{E-Init}]{}{
    \EVAL{\mathtt{new}_k~\sequence{\OBJECTID}=\sequence{\CLASSID(\sequence{\VAROBJECTID})}},
    \HEAP[\sequence{\OBJECTID} \mapsto \sequence{\CLASSID(\sequence{\nil})}]
    \to
    \EVAL{\OBJECTID_k},
    \HEAP[\sequence{\OBJECTID} \mapsto \sequence{\CLASSID(\sequence{\VAROBJECTID})}]
  }
\end{array}
\end{math}
}
\end{table}

Nella Tabella~\ref{tab:obj-eval} viene mostrato in che modo avviene la valutazione
delle espressioni del linguaggio {\olang}.
In queste regole compare lo \emph{heap}, che rappresenta l'area di memoria
in cui vengono allocati gli oggetti creati a runtime.
Visto che in Java tutti gli oggetti vengono creati a runtime lo \emph{heap}
contiene quindi l'insieme di tutti gli oggetti di un programma.
Le regole presenti sono descritte singolarmente nei paragrafi successivi.

\paragraph{E-Field}
Questa regola descrive l'accesso ad un campo dell'oggetto.
La regola ha due premesse: l'oggetto $\OBJECTID$, allocato nello heap, \`e di
classe $\CLASSID$ e al suo costruttore sono stati passati i parametri 
$\sequence{\VAROBJECTID}$. I campi della classe $\CLASSID$ sono $\sequence{\FIELDID}$.
La conclusione dice che l'accesso al campo $i$-esimo dell'oggetto, si riduce al
valore dell'$i$-esimo parametro passato al costruttore dell'oggetto stesso.

\paragraph{E-Method}
Questa regola descrive la chiamata di un metodo.
La regola ha due premesse: l'oggetto $\OBJECTID$, allocato nello heap, \`e di
classe $\CLASSID$ e al suo costruttore sono stati passati i parametri 
$\sequence{\VAROBJECTID}$. Il corpo del metodo $\METHODID$ della classe $\CLASSID$ 
\`e l'espressione $\EXPR$ e i suoi parametri sono $\sequence{\VAR}$.
La conclusione dice che l'invocazione del metodo $\METHODID$ dell'oggetto $\OBJECTID$,
passandogli come parametri i valori $\sequence{\OBJECTID}$, si riduce al corpo del metodo stesso,
in cui i parametri formali vengono sostituiti con i parametri attuali e il nome dell'oggetto
viene sostituito con $\THIS$.\footnote{$\THIS$ \`e una parola riservata usata 
per far riferimento all'oggetto corrente. In alcuni linguaggi al posto di 
$\THIS$ si usa \texttt{self} o \texttt{Me}.}

\paragraph{E-Alloc}

Questa regola descrive la prima fase dell'allocazione di una lista di oggetti nello heap.
La premessa della regola dice che i nomi usati per i nuovi oggetti non sono gi\`a usati.
La conclusione dice che l'allocazione dei nuovi oggetti si riduce a se stessa, sostituendo
i nuovi nomi degli oggetti con quelli definiti dal programmatore. Inoltre nello
heap verranno allocati gli oggetti corrispondenti chiamando il costruttore di default di
ogni classe.

\paragraph{E-Init}

Questa regola descrive la seconda fase dell'allocazione di una lista di oggetti nello heap:
la loro inizializzazione. Dopo che gli oggetti sono stati gi\`a allocati nello heap, l'espressione di
allocazione degli oggetti si riduce al $k$-esimo oggetto definito, avendo chiamato i costruttori
dei vari oggetti con i parametri attuali.\\

Vediamo ora un esempio di applicazione delle regole appena descritte, indicando
con $\emptyset$ lo heap vuoto:
%
\begin{ScriptMath}
(new$_1$ x = Pair(1, 2)).first(),$\emptyset$
(new$_1$ o = Pair(1, 2)).first(),h[o $\mapsto$ Pair(nil, nil)]
o.first(),h[o $\mapsto$ Pair(1, 2)]
1
\end{ScriptMath}
%
In questo esempio supponiamo di avere a disposizione come costanti i numeri 
interi, le coppie e una funzione \lstinline!first! che presa una coppia
restituisce la prima componente.
All'inizio lo \emph{heap} \`e vuoto e la valutazione dell'espressione di
allocazione della coppia (1, 2) si riduce all'allocazione nello \emph{heap}
di un nuovo oggetto non ancora inizializzato, sfruttando la regola di riduzione
\textit{E-Alloc}.
A questo punto l'espressione di allocazione della coppia si riduce
al puntatore nello \emph{heap} dell'oggetto stesso e l'oggetto viene quindi
inizializzato con i parametri attuali, sfruttando la regola \textit{E-Init}.
Ora applicando la regola \textit{E-Method} il corpo del metodo 
\lstinline!first!
viene sostituito all'intera espressione, e il risultato della valutazione
\`e la costante 1.


\section{\label{sec:comp}Il compilatore}

Prima di definire la funzione di compilazione dal linguaggio {\flang} 
al linguaggio {\olang}, \`e importante conoscere la struttura
delle classi di supporto runtime.
Esistono due tipi di classi di supporto: una
 per rappresentare il concetto di \emph{chiusura}
e l'altra per rappresentare il concetto di \emph{applicazione parziale}.
La definizione di queste classi \`e mostrata in Tabella~\ref{tab:runtime}.
In questa tabella il parametro $\MAXARGS$ indica il numero\footnote{Per gli esperimenti di compilazione abbiamo settato a 4 questo parametro} massimo 
di argomenti che pu\`o avere una funzione nel linguaggio {\flang}, il parametro $m$ indica l'arit\`a della funzione e il parametro $n$ indica il numero di
argomenti che gi\`a sono stati passati alla funzione, creando cos\`i 
un'applicazione parziale.

La classe \lstinline!Closure!, serve ad implementare le chiusure ed esisteranno $\MAXARGS$
classi $\CLOSUREID{m}$. 
Questa classe non ha campi e ha dei metodi che servono per applicare la funzione agli argomenti passati. Questi metodi si differenziano proprio
in base al numero di argomenti. Infatti se ad una funzione vengono passati
meno argomenti di quanti se ne aspetta, va creata un'applicazione parziale; invece se il numero di argomenti passati \`e maggiore del numero di 
argomenti attesi, prima si satura l'applicazione con gli argomenti attesi e al risultato si applicano gli argomenti restanti.
A questa classe manca proprio il metodo per saturare l'applicazione, ma questo verr\`a definito successivamente dalla classe che estender\`a la chiusura.

La classe \lstinline!PAP!, serve ad implementare l'applicazione parziale ed esisteranno 
$\frac{\MAXARGS(\MAXARGS - 1)}{2}$ classi di questo tipo.
Infatti una funzione con $n$ argomenti avr\`a $n - 1$ possibili 
applicazioni parziali e le funzioni possono avere da 1 a $\MAXARGS$ argomenti.
La somma di tutte le possibili applicazioni parziali \`e quindi $\sum_{i = 1}
^{\MAXARGS - 1}i$ che si semplifica in $\frac{\MAXARGS(\MAXARGS - 1)}{2}$.
Questa classe ha $n + 1$ campi per memorizzare la chiusura che l'ha generata e
i parametri gi\`a passati alla funzione ($n$).
Il costruttore della classe si limita ad inizializzare i campi 
con i rispettivi valori e come per la classe \lstinline!Closure! esistono dei metodi
per gestire correttamente il numero di argomenti passati.


\begin{table}%[!h]
\caption{\label{tab:runtime}\strut Definizione delle classi $\CLOSUREID{m}$ e $\PAPID{m}{n}$.}
\framebox[\textwidth]{
\begin{small}
\begin{math}
\displaystyle
\begin{array}{@{}l@{}}
  \mathtt{class}~\CLOSUREID{m}~\mathtt{extends}~\mathtt{Object}~\{
  \hspace{5cm} 1 \le m \le \MAXARGS 
  \\
  \quad \CLOSUREID{m}()~\{
  ~\} \\
  \quad \APPLY{\seqlen{\sequence{x}}}(\sequence{x})
  \hfill 1 \le \seqlen{\sequence{x}} < m \\
  \qquad\{~
  \mathtt{new}_1~\mathit{pap}=\PAPID{m}{\seqlen{\sequence{x}}}(\mathtt{this},\sequence{x})
  ~\}
  \\
  \quad \APPLY{\seqlen{\sequence{x},\sequence{y}}}(\sequence{x},\sequence{y})
  \hfill m = \seqlen{\sequence{x}} < \seqlen{\sequence{x},\sequence{y}} \le \MAXARGS
  \\
  \qquad\{~
  \mathtt{this}.\APPLY{m}(\sequence{x}).\APPLY{\seqlen{\sequence{y}}}(\sequence{y})
  ~\}
  \\
  \}
  \\\\
  \mathtt{class}~\PAPID{m}{n}~\mathtt{extends}~\mathtt{Object}~\{
  \hfill 1 \le n < m \le \MAXARGS
  \\
  \quad \mathit{cls}, \sequence{\VAL};
  \hfill n = \seqlen{\sequence{\VAL}} \\
  \quad \PAPID{m}{n}(\mathit{cls},\sequence{\VAL})~\{~
  \mathtt{this}.\mathit{cls},\sequence{\VAL} = \mathit{cls},\sequence{\VAL};
  ~\} \\
  \quad \APPLY{\seqlen{\sequence{x}}}(\sequence{x})
  \hfill 1 \le \seqlen{\sequence{x}} < m - n
  \\
  \qquad\{~
  \mathtt{new}_1~\mathit{pap}=\PAPID{m}{n + \seqlen{\sequence{x}}}(\mathtt{this}.\mathit{cls},\mathtt{this}.\sequence{\VAL},\sequence{x})
  ~\}
  \\
  \quad \APPLY{\seqlen{\sequence{x}}}(\sequence{x})
  \hfill m - n = \seqlen{\sequence{x}}
  \\
  \qquad\{~
  \mathtt{this}.\mathit{cls}.\APPLY{m}(\mathtt{this}.\sequence{\VAL},\sequence{x})
  ~\}
  \\
  \quad \APPLY{\seqlen{\sequence{x},\sequence{y}}}(\sequence{x},\sequence{y})
  \hfill m - n = \seqlen{\sequence{x}} < \seqlen{\sequence{x},\sequence{y}} \le \MAXARGS
  \\
  \qquad\{~
  \mathtt{this}.\mathit{cls}.\APPLY{m}(\mathtt{this}.\sequence{\VAL},\sequence{x}).\APPLY{\seqlen{\sequence{y}}}(\sequence{y})
  ~\}
  \\
  \} 
\end{array}
\end{math}
\end{small}
}
\end{table}

Dopo aver descritto le classi di supporto, si pu\`o procedere a descrivere la 
funzione di compilazione dal linguaggio {\flang} al linguaggio {\olang}.
La funzione di compilazione \`e mostrata nella Tabella~\ref{tab:comp}.

Data un'espressione $\EXPR$ del linguaggio {\flang} scriviamo 
$\COMPILE{\EXPR}{\sequence{y}}f$ per indicare in che modo l'espressione
$\EXPR$ viene compilata nel linguaggio {\olang}, essendo
$\sequence{y}$  la lista dei nomi delle variabili \emph{legate} 
ed $f$  il nome della funzione all'interno del quale \`e presente l'espressione 
$\EXPR$.

Una variabile $x$ viene compilata come se stessa se \`e presente nella lista
delle variabili legate, viene compilata come $\THIS$, se il suo nome corrisponde
al nome della funzione all'interno del quale \`e definita oppure viene compilata come
l'accesso al campo $x$ dell'oggetto $\THIS$.

La definizione di una funzione viene compilata con l'allocazione di un nuovo oggetto.
Il nuovo oggetto ha come classe base la classe $\CLOSUREID{m}$, dove $m$ \`e il 
numero di parametri della funzione.
L'oggetto ha tanti campi quante sono le variabili libere presenti nel corpo
della funzione (tranne i parametri della funzione stessa) e 
il costruttore della classe si limita ad inizializzare i campi dell'oggetto
con i valori attuali.
La classe ha un solo metodo, che corrisponde alla saturazione della funzione, 
ed il suo corpo corrisponde alla compilazione del corpo della funzione nel 
linguaggio {\flang}.

L'applicazione di una funzione viene compilata con la chiamata del metodo
$\APPLY m$ (dove $m$ \`e il numero di parametri passati),
sull'oggetto derivante dalla compilazione della prima espressione.

La definizione di $n$ funzioni mutuamente ricorsive viene compilata in maniera
simile alla compilazione di una funzione. Questa volta per\`o, saranno creati
$n$ oggetti e i campi degli oggetti saranno usati per contenere le variabili
libere presenti nel corpo della funzione, tranne i parametri della funzione e il
nome della funzione stessa.

\begin{table}%[!h]
\caption{\label{tab:comp}\strut Compilazione del linguaggio {\flang} nel linguaggio {\olang}.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{rcl}
  \COMPILE{x}{\sequence{y}}f & = &
  \begin{cases}
    x & x \in \sequence{y} \\
    \THIS & x = f \\
    \THIS.x & \text{altrimenti} 
  \end{cases}
  \\
  \COMPILE{\mathtt{fun}~\sequence{x} \to \EXPR}{\sequence{y}}{f} & = &
  \mathtt{new}_1 {?} = \CLASSID(\COMPILE{\sequence{z}}{\sequence{y}}{f}) \\
  \text{dove}
  & &
  \sequence{z} = \fv(\EXPR) \setminus \sequence{x} \\
  & & 
  \mathtt{class}~\CLASSID~\mathtt{extends}~\CLOSUREID{\seqlen{\sequence{x}}}~\{ \\
  & & \quad \sequence{z}; \\
  & & \quad \CLASSID(\sequence{z})~\{ \THIS.\sequence{z} = \sequence{z}; \} \\
  & & \quad \APPLY{\seqlen{\sequence{x}}}(\sequence{x})~\{ \COMPILE{\EXPR}{\sequence{x}}{{?}} \} \\
  & & \}
  \\
  \COMPILE{\EXPR~\sequence{\EXPR}}{\sequence{y}}{f} & = &
  \COMPILE{\EXPR}{\sequence{y}}{f}.\APPLY{\seqlen{\sequence{\EXPR}}}(\COMPILE{\sequence{\EXPR}}{\sequence{y}}{f})
  \\
  \COMPILE{\mathtt{fix}_k~\sequence{f}=\sequence{\mathtt{fun}~\sequence{x}\to\EXPR}}{\sequence{y}}{f} & = & 
  \mathtt{new}_k~\sequence{f}=\sequence{\CLASSID(\COMPILE{\sequence{z}}{\sequence{y}}{f})}
  \\
  \text{dove}
  & &
  \sequence{z}_i = \fv(\EXPR_i) \setminus f_i,\sequence{x}_i \\
  & & \mathtt{class}~\CLASSID_i~\mathtt{extends}~\CLOSUREID{\seqlen{\sequence{x}_i}}~\{ \\
  & & \quad \sequence{z}_i; \\
  & & \quad \CLASSID_i(\sequence{z}_i)~\{ \THIS.\sequence{z}_i = \sequence{z}_i; \} \\
  & & \quad \APPLY{\seqlen{\sequence{x}_i}}(\sequence{x}_i)~\{ \COMPILE{\EXPR_i}{\sequence{x}_i}{{f_i}} \} \\
  & & \}
\end{array}
\end{math}
}
\end{table}

\subsection {Esempi di compilazione da \flang~ a \olang}

In questa sezione vengono mostrati degli esempi di compilazione dal 
linguaggio {\flang} al linguaggio {\olang}, prendendo spunto 
dagli esempi fatti nella sezione~\ref{sec:flang} a pagina~\pageref{sec:flang}.

\begin{table}%[!h]
\caption{\label{tab:es1}\strut Esempio 1.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{l c@{\quad\quad}  l}
  \mathtt{fun~~f~g~x \to f~(g~ x)}  
 & &
  \mathtt{new}_1~ \mathtt{t_0 = \CLASSID()}\\
  & &
  \mathtt{class~\CLASSID~extends~Closure\_3}~\{ \\
  & & \quad \mathtt{apply\_3~(f,~g,~ x)~}\{ \\
  & & \quad \quad \mathtt{f.apply\_1(g.apply\_1(x))} \\
  & & \quad \} \\ 
  & & \}
  \\
\end{array}
\end{math}
}
\end{table}

L'esempio in tabella \ref{tab:es1} mostra la compilazione della 
versione anonima della funzione \lstinline!compose!.
 Il nome dell'oggetto creato ($\mathtt{t_0}$) \`e un nome 
non visibile al 
programmatore, e il nome della classe ($\CLASSID$) \`e un nome non ancora
usato per nessuna altra classe.
Il corpo dell'unico metodo della classe consiste nella chiamata annidata 
al metodo $\mathtt{apply\_1}$, degli oggetti \lstinline!f! e \lstinline!g!.


\begin{table}%[!h]
\caption{\label{tab:es2}\strut Esempio 2.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{l c@{\quad\quad}  l}
   \mathtt{fix_1~ f~ =~ fun~ x \to f~ x}  
 & &
  \mathtt{new_1~ f = \CLASSID()}\\
  & &
  \mathtt{class~\CLASSID~extends~Closure\_1}~\{ \\
  & & \quad \mathtt{apply\_1~(x)}~\{ \\
  & & \quad \quad \mathtt{\THIS.apply\_1(x)} \\
  & & \quad \} \\ 
  & & \}
  \\
\end{array}
\end{math}
}
\end{table}


L'esempio in tabella \ref{tab:es2} mostra la compilazione della funzione 
ricorsiva necessaria a creare un loop infinito.
 Rispetto all'esempio precedente, il nome dell'oggetto creato questa 
volta \`e proprio il nome della funzione. Inoltre in questo esempio si vede 
l'uso dell'identificare $\THIS$ per fare riferimento all'oggetto corrente.


\begin{table}%[!h]
\caption{\label{tab:es3}\strut Esempio 3.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{l c@{\quad\quad}  l}
   \mathtt{fix_2~ f = fun~ x \to~ g~ x}  & & 
\mathtt{new_2~ f = \CLASSID(g)~g = D(f)}\\
   \mathtt{~ g =~ fun~ y \to~ f~ y}  & & 
\mathtt{class~\CLASSID~extends}~
  \mathtt{Closure\_1}~\{ \\
  & & \quad \mathtt{g;} \\
  & & \quad \mathtt{\CLASSID(g)}~\{ \THIS \mathtt{.g = g;} \} \\
  & & \quad \mathtt{apply\_1(x)}~\{ \\
  & & \qquad \mathtt{\THIS .g.apply\_1(x)} \\
  & & \quad \} \\ 
  & & \}
  \\
  & & \mathtt{class~D~extends}~
  \mathtt{Closure\_1}~\{ \\
  & & \quad \mathtt{f;} \\
  & & \quad \mathtt{D(f)}~\{ \THIS \mathtt{.f = f;} \} \\
  & & \quad \mathtt{apply\_1( y )}~\{ \\
  & & \quad \quad \THIS \mathtt{.f.apply\_1(y)} \\
  & & \quad \} \\ 
  & & \}
  \\
\end{array}
\end{math}
}
\end{table}


L'esempio in tabella \ref{tab:es3} mostra la compilazione di due funzioni 
mutuamente ricorsive. In questo caso, definendo due funzioni, vengono
creati due oggetti. Questa volta gli oggetti creati hanno anche un campo, che 
viene inizializzato dal costruttore della classe.
Inoltre in questo esempio si vede anche l'accesso ad un campo
della classe su cui poi viene invocato il metodo $\mathtt{apply\_1}$, 
passandogli il parametro corretto.
